/*
 * File      : device.c
 * This file is part of RT-Thread RTOS
 * COPYRIGHT (C) 2006 - 2013, RT-Thread Development Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Change Logs:
 * Date           Author       Notes
 * 2007-01-21     Bernard      the first version
 * 2010-05-04     Bernard      add rt_device_init implementation
 * 2012-10-20     Bernard      add device check in register function,
 *                             provided by Rob <rdent@iinet.net.au>
 * 2012-12-25     Bernard      return RT_EOK if the device interface not exist.
 * 2013-07-09     Grissiom     add ref_count support
 * 2016-04-02     Bernard      fix the open_flag initialization issue.
 */

#include <rtthread.h>

#ifdef RT_USING_DEVICE

/**
 * This function registers a device driver with specified name.
 *
 * @param dev the pointer of device driver structure
 * @param name the device driver's name
 * @param flags the flag of device
 *
 * @return the error code, RT_EOK on initialization successfully.
 */
rt_err_t rt_device_register(rt_device_t dev,
                            const char* name,
                            rt_uint16_t flags)
{
	if(dev == RT_NULL)
		return -RT_ERROR;

	if(rt_device_find(name) != RT_NULL)
		return -RT_ERROR;

	rt_object_init(&(dev->parent), RT_Object_Class_Device, name);
	dev->flag = flags;
	dev->ref_count = 0;
	dev->open_flag = 0;

#if defined(RT_USING_POSIX)
	dev->fops = RT_NULL;
	rt_list_init(&(dev->wait_queue));
#endif

	return RT_EOK;
}
RTM_EXPORT(rt_device_register);

/**
 * This function removes a previously registered device driver
 *
 * @param dev the pointer of device driver structure
 *
 * @return the error code, RT_EOK on successfully.
 */
rt_err_t rt_device_unregister(rt_device_t dev)
{
	RT_ASSERT(dev != RT_NULL);

	rt_object_detach(&(dev->parent));

	return RT_EOK;
}
RTM_EXPORT(rt_device_unregister);

/**
 * This function initializes all registered device driver
 *
 * @return the error code, RT_EOK on successfully.
 *
 * @deprecated since 1.2.x, this function is not needed because the initialization
 *             of a device is performed when applicaiton opens it.
 */
rt_err_t rt_device_init_all(void)
{
	return RT_EOK;
}

/**
 * This function finds a device driver by specified name.
 *
 * @param name the device driver's name
 *
 * @return the registered device driver on successful, or RT_NULL on failure.
 */
rt_device_t rt_device_find(const char* name)
{
	struct rt_object* object;
	struct rt_list_node* node;
	struct rt_object_information* information;

	/* enter critical */
	if(rt_thread_self() != RT_NULL)
		rt_enter_critical();

	/* try to find device object */
	information = rt_object_get_information(RT_Object_Class_Device);
	RT_ASSERT(information != RT_NULL);

	for(node  = information->object_list.next;
	        node != &(information->object_list);
	        node  = node->next) {
		object = rt_list_entry(node, struct rt_object, list);

		if(rt_strncmp(object->name, name, RT_NAME_MAX) == 0) {
			/* leave critical */
			if(rt_thread_self() != RT_NULL)
				rt_exit_critical();

			return (rt_device_t)object;
		}
	}

	/* leave critical */
	if(rt_thread_self() != RT_NULL)
		rt_exit_critical();

	/* not found */
	return RT_NULL;
}
RTM_EXPORT(rt_device_find);

#ifdef RT_USING_HEAP
/**
 * This function creates a device object with user data size.
 *
 * @param type, the kind type of this device object.
 * @param attach_size, the size of user data.
 *
 * @return the allocated device object, or RT_NULL when failed.
 */
rt_device_t rt_device_create(int type, int attach_size)
{
	int size;
	rt_device_t device;

	size = RT_ALIGN(sizeof(struct rt_device), RT_ALIGN_SIZE);
	size += attach_size;

	device = (rt_device_t)rt_malloc(size);

	if(device) {
		rt_memset(device, 0x0, sizeof(struct rt_device));
		device->type = (enum rt_device_class_type)type;
	}

	return device;
}
RTM_EXPORT(rt_device_create);

/**
 * This function destroy the specific device object.
 *
 * @param device, the specific device object.
 */
void rt_device_destroy(rt_device_t device)
{
	/* unregister device firstly */
	rt_device_unregister(device);

	/* release this device object */
	rt_free(device);
}
RTM_EXPORT(rt_device_destroy);
#endif

/**
 * This function will initialize the specified device
 *
 * @param dev the pointer of device driver structure
 *
 * @return the result
 */
rt_err_t rt_device_init(rt_device_t dev)
{
	rt_err_t result = RT_EOK;

	RT_ASSERT(dev != RT_NULL);

	/* get device init handler */
	if(dev->init != RT_NULL) {
		if(!(dev->flag & RT_DEVICE_FLAG_ACTIVATED)) {
			result = dev->init(dev);

			if(result != RT_EOK) {
				rt_kprintf("To initialize device:%s failed. The error code is %d\n",
				           dev->parent.name, result);
			} else {
				dev->flag |= RT_DEVICE_FLAG_ACTIVATED;
			}
		}
	}

	return result;
}

/**
 * This function will open a device
 *
 * @param dev the pointer of device driver structure
 * @param oflag the flags for device open
 *
 * @return the result
 */
rt_err_t rt_device_open(rt_device_t dev, rt_uint16_t oflag)
{
	rt_err_t result = RT_EOK;

	RT_ASSERT(dev != RT_NULL);

	/* if device is not initialized, initialize it. */
	if(!(dev->flag & RT_DEVICE_FLAG_ACTIVATED)) {
		if(dev->init != RT_NULL) {
			result = dev->init(dev);

			if(result != RT_EOK) {
				rt_kprintf("To initialize device:%s failed. The error code is %d\n",
				           dev->parent.name, result);

				return result;
			}
		}

		dev->flag |= RT_DEVICE_FLAG_ACTIVATED;
	}

	/* device is a stand alone device and opened */
	if((dev->flag & RT_DEVICE_FLAG_STANDALONE) &&
	        (dev->open_flag & RT_DEVICE_OFLAG_OPEN)) {
		return -RT_EBUSY;
	}

	/* call device open interface */
	if(dev->open != RT_NULL) {
		result = dev->open(dev, oflag);
	} else {
		/* set open flag */
		dev->open_flag = (oflag & RT_DEVICE_OFLAG_MASK);
	}

	/* set open flag */
	if(result == RT_EOK || result == -RT_ENOSYS) {
		dev->open_flag |= RT_DEVICE_OFLAG_OPEN;

		dev->ref_count++;
		/* don't let bad things happen silently. If you are bitten by this assert,
		 * please set the ref_count to a bigger type. */
		RT_ASSERT(dev->ref_count != 0);
	}

	return result;
}
RTM_EXPORT(rt_device_open);

/**
 * This function will close a device
 *
 * @param dev the pointer of device driver structure
 *
 * @return the result
 */
rt_err_t rt_device_close(rt_device_t dev)
{
	rt_err_t result = RT_EOK;

	RT_ASSERT(dev != RT_NULL);

	if(dev->ref_count == 0)
		return -RT_ERROR;

	dev->ref_count--;

	if(dev->ref_count != 0)
		return RT_EOK;

	/* call device close interface */
	if(dev->close != RT_NULL) {
		result = dev->close(dev);
	}

	/* set open flag */
	if(result == RT_EOK || result == -RT_ENOSYS)
		dev->open_flag = RT_DEVICE_OFLAG_CLOSE;

	return result;
}
RTM_EXPORT(rt_device_close);

/**
 * This function will read some data from a device.
 *
 * @param dev the pointer of device driver structure
 * @param pos the position of reading
 * @param buffer the data buffer to save read data
 * @param size the size of buffer
 *
 * @return the actually read size on successful, otherwise negative returned.
 *
 * @note since 0.4.0, the unit of size/pos is a block for block device.
 */
rt_size_t rt_device_read(rt_device_t dev,
                         rt_off_t    pos,
                         void*       buffer,
                         rt_size_t   size)
{
	RT_ASSERT(dev != RT_NULL);

	if(dev->ref_count == 0) {
		rt_set_errno(-RT_ERROR);
		return 0;
	}

	/* call device read interface */
	if(dev->read != RT_NULL) {
		return dev->read(dev, pos, buffer, size);
	}

	/* set error code */
	rt_set_errno(-RT_ENOSYS);

	return 0;
}
RTM_EXPORT(rt_device_read);

/**
 * This function will write some data to a device.
 *
 * @param dev the pointer of device driver structure
 * @param pos the position of written
 * @param buffer the data buffer to be written to device
 * @param size the size of buffer
 *
 * @return the actually written size on successful, otherwise negative returned.
 *
 * @note since 0.4.0, the unit of size/pos is a block for block device.
 */
rt_size_t rt_device_write(rt_device_t dev,
                          rt_off_t    pos,
                          const void* buffer,
                          rt_size_t   size)
{
	RT_ASSERT(dev != RT_NULL);

	if(dev->ref_count == 0) {
		rt_set_errno(-RT_ERROR);
		return 0;
	}

	/* call device write interface */
	if(dev->write != RT_NULL) {
		return dev->write(dev, pos, buffer, size);
	}

	/* set error code */
	rt_set_errno(-RT_ENOSYS);

	return 0;
}
RTM_EXPORT(rt_device_write);

/**
 * This function will perform a variety of control functions on devices.
 *
 * @param dev the pointer of device driver structure
 * @param cmd the command sent to device
 * @param arg the argument of command
 *
 * @return the result
 */
rt_err_t rt_device_control(rt_device_t dev, int cmd, void* arg)
{
	RT_ASSERT(dev != RT_NULL);

	/* call device write interface */
	if(dev->control != RT_NULL) {
		return dev->control(dev, cmd, arg);
	}

	return -RT_ENOSYS;
}
RTM_EXPORT(rt_device_control);

/**
 * This function will set the reception indication callback function. This callback function
 * is invoked when this device receives data.
 *
 * @param dev the pointer of device driver structure
 * @param rx_ind the indication callback function
 *
 * @return RT_EOK
 */
rt_err_t
rt_device_set_rx_indicate(rt_device_t dev,
                          rt_err_t (*rx_ind)(rt_device_t dev, rt_size_t size))
{
	RT_ASSERT(dev != RT_NULL);

	dev->rx_indicate = rx_ind;

	return RT_EOK;
}
RTM_EXPORT(rt_device_set_rx_indicate);

/**
 * This function will set the indication callback function when device has
 * written data to physical hardware.
 *
 * @param dev the pointer of device driver structure
 * @param tx_done the indication callback function
 *
 * @return RT_EOK
 */
rt_err_t
rt_device_set_tx_complete(rt_device_t dev,
                          rt_err_t (*tx_done)(rt_device_t dev, void* buffer))
{
	RT_ASSERT(dev != RT_NULL);

	dev->tx_complete = tx_done;

	return RT_EOK;
}
RTM_EXPORT(rt_device_set_tx_complete);

#endif
